<template>
	<view class="index-container">
		

		
		<!-- 扫码区域 -->
		<view class="scan-container">
			<view class="scan-box" @tap="scanCode">
				<!-- 扫码框 -->
				<view class="scan-frame">
					<!-- 扫描线动画 -->
					<view class="scan-line" :style="{top: scanLineTop + 'rpx'}"></view>
				</view>
			</view>
			
			<!-- 提示文字 -->
			<view class="scan-tip">
				<text>请对准充电桩二维码</text>
			</view>
			
			<!-- 蓝牙连接状态 -->
			<view v-if="connectionStatus" class="connection-status" :class="connectionStatusClass">
				<text>{{ connectionStatus }}</text>
			</view>
			
			<!-- 信息按钮 -->
			<view class="info-btn" @tap="showInfo">
				<text class="info-icon">i</text>
			</view>
		</view>
		
		<!-- 底部导航栏 -->
		<tab-bar></tab-bar>
	</view>
</template>

<script>
	import TabBar from '@/components/TabBar.vue'
	import GlobalBluetoothManager from '@/utils/GlobalBluetoothManager.js'

	export default {
		components: {
			TabBar
		},
		data() {
			return {
				currentTime: '12:31',
				scanLineTop: 0,
				scanAnimation: null,
				scanning: false,
				searchInterval: null,
				connectionStatus: '',
				connectionStatusClass: '',
				bluetoothInitRetryCount: 0,
				connectRetryCount: 0,
				maxRetries: 3
			}
		},
		onLoad() {
			// 初始化蓝牙，但添加错误处理和重试机制
			this.initBluetoothWithRetry();
			
			this.updateTime();
			// 每分钟更新一次时间
			setInterval(this.updateTime, 60000);
			// 启动扫描线动画
			this.startScanAnimation();
		},
		onShow() {
			// 页面显示时启动扫描线动画
			this.startScanAnimation();
		},
		onHide() {
			// 页面隐藏时清除动画
			this.clearScanAnimation();
			// 清理资源
			this.cleanupResources();
		},
		onUnload() {
			// 页面卸载时清理资源
			this.clearScanAnimation();
			this.cleanupResources();
		},
		methods: {
			// 带重试机制的蓝牙初始化
			initBluetoothWithRetry() {
				if (this.bluetoothInitRetryCount >= this.maxRetries) {
					console.warn('蓝牙初始化重试次数已达上限，不再尝试');
					return Promise.reject(new Error('蓝牙初始化失败，已达最大重试次数'));
				}
				
				return GlobalBluetoothManager.init()
					.then(res => {
						console.log('蓝牙初始化成功', res);
						this.bluetoothInitRetryCount = 0; // 重置重试计数
						return res;
					})
					.catch(err => {
						console.error('蓝牙初始化失败，尝试重试', err);
						this.bluetoothInitRetryCount++;
						
						// 延迟1秒后重试
						return new Promise((resolve, reject) => {
							setTimeout(() => {
								this.initBluetoothWithRetry()
									.then(resolve)
									.catch(reject);
							}, 1000);
						});
					});
			},
		
			updateTime() {
				const date = new Date();
				const hours = date.getHours().toString().padStart(2, '0');
				const minutes = date.getMinutes().toString().padStart(2, '0');
				this.currentTime = `${hours}:${minutes}`;
			},
			
			// 开始扫描线动画
			startScanAnimation() {
				this.clearScanAnimation();
				this.scanLineTop = 0;
				
				this.scanAnimation = setInterval(() => {
					if (this.scanLineTop >= 550) {
						this.scanLineTop = 0;
					} else {
						this.scanLineTop += 5;
					}
				}, 30);
			},
			
			// 清除扫描线动画
			clearScanAnimation() {
				if (this.scanAnimation) {
					clearInterval(this.scanAnimation);
					this.scanAnimation = null;
				}
			},
			
			// 扫描二维码
			scanCode() {
				if (this.scanning) return;
				this.scanning = true;
				
				uni.scanCode({
					scanType: ['qrCode'],
					success: (res) => {
						console.log('扫码成功：', res);
						this.handleScanResult(res.result);
					},
					fail: (err) => {
						console.error('扫码失败：', err);
						this.scanning = false;
						uni.showToast({
							title: '扫码失败，请重试',
							icon: 'none'
						});
					},
					complete: () => {
						this.scanning = false;
					}
				});
			},
			
			// 设置连接状态
			setConnectionStatus(status, type = 'info') {
				this.connectionStatus = status;
				this.connectionStatusClass = `status-${type}`; // status-info, status-success, status-error
				
				// 如果是成功或错误状态，3秒后自动清除
				if (type === 'success' || type === 'error') {
					setTimeout(() => {
						this.connectionStatus = '';
					}, 3000);
				}
			},
			
			// 处理扫码结果
			handleScanResult(result) {
				try {
					console.log('扫码结果:', result);
					
					// 从二维码中提取设备ID
					let deviceId = this.extractDeviceIdFromQR(result);
					
					if (!deviceId) {
						throw new Error('无法从二维码中获取有效的设备ID');
					}
					
					// 显示加载提示
					uni.showLoading({
						title: '正在连接充电桩...',
						mask: true
					});
					
					// 设置连接状态
					this.setConnectionStatus('正在连接蓝牙设备...', 'info');
					
					// 连接蓝牙设备
					this.connectBluetoothDevice(deviceId)
						.catch(err => {
							// 确保在错误时隐藏 loading
							try {
								uni.hideLoading();
							} catch (e) {
								console.warn('隐藏 loading 失败:', e);
							}
							throw err;
						});
				} catch (e) {
					console.error('处理扫码结果出错：', e);
					// 确保在错误时隐藏 loading
					try {
						uni.hideLoading();
					} catch (e) {
						console.warn('隐藏 loading 失败:', e);
					}
					this.setConnectionStatus('二维码无效', 'error');
					uni.showToast({
						title: '无效的二维码',
						icon: 'none'
					});
				}
			},
			
			// 从二维码结果中提取设备ID
			extractDeviceIdFromQR(result) {
				let deviceId = '';
				console.log("扫描结果原始内容:", result);
				
				try {
					// 尝试解析为 JSON
					const resultObj = JSON.parse(result);
					deviceId = resultObj.deviceId || resultObj.device_id || resultObj.id || '';
				} catch (e) {
					// 如果不是JSON，尝试其他格式
					const match = result.match(/deviceId[=:]\s*([^&\s]+)/i);
					if (match && match[1]) {
						deviceId = match[1];
					} else {
						// 如果没有明确的格式，假设整个字符串就是设备ID
						deviceId = result.trim();
					}
				}
				
				return deviceId;
			},
			
			// 清理所有资源
			cleanupResources() {
				// 清除定时器
				if (this.searchInterval) {
					clearInterval(this.searchInterval);
					this.searchInterval = null;
				}
				
				// 隐藏加载提示
				uni.hideLoading();
				
				// 重置重试计数器
				this.connectRetryCount = 0;
			},
			
			// 清理蓝牙搜索资源
			cleanupBluetoothSearch() {
				// 清除搜索定时器
				if (this.searchInterval) {
					clearInterval(this.searchInterval);
					this.searchInterval = null;
				}
			},
			
			// 带重试机制的蓝牙连接
			connectBluetoothWithRetry(deviceId) {
				if (this.connectRetryCount >= this.maxRetries) {
					return Promise.reject(new Error('连接失败，已达最大重试次数'));
				}
				
				return GlobalBluetoothManager.connect(deviceId)
					.then(res => {
						this.connectRetryCount = 0; // 重置重试计数
						return res;
					})
					.catch(err => {
						console.error('连接蓝牙设备失败，尝试重试', err);
						this.connectRetryCount++;
						this.setConnectionStatus(`连接失败，正在重试 (${this.connectRetryCount}/${this.maxRetries})...`, 'info');
						
						// 延迟1秒后重试
						return new Promise((resolve, reject) => {
							setTimeout(() => {
								this.connectBluetoothWithRetry(deviceId)
									.then(resolve)
									.catch(reject);
							}, 1000);
						});
					});
			},
			
			// 直接连接蓝牙设备，不进行扫描
			directConnectBluetooth(deviceId, originalQrResult) {
				console.log('尝试直接连接蓝牙设备，原始ID:', deviceId);
				
				// 检查设备ID是否有效
				if (!deviceId || deviceId.trim() === '') {
					this.setConnectionStatus('设备ID无效', 'error');
					uni.hideLoading();
					uni.showToast({
						title: '无效的设备ID,请重新扫码',
						icon: 'none',
						duration: 2000
					});
					return;
				}
				
				// 重置重试计数
				this.connectRetryCount = 0;
				
				// 确保蓝牙是可用的
				this.initBluetoothWithRetry()
					.then(() => {
						this.setConnectionStatus(`正在连接设备: ${deviceId}...`, 'info');
						
						// 设置连接超时 - 增加到30秒
						const connectTimeout = setTimeout(() => {
							// 如果30秒内没有连接成功或失败，则视为超时
							if (GlobalBluetoothManager.bluetoothManager.isConnecting) {
								// 如果仍处于连接状态，尝试获取错误详情
								const lastError = GlobalBluetoothManager.bluetoothManager.getLastError();
								const errorDetails = lastError ? `(${lastError.phase}: ${lastError.message})` : '';
								
								this.setConnectionStatus(`连接超时 ${errorDetails}`, 'error');
								uni.hideLoading();
								uni.showToast({
									title: '连接超时，请确认充电桩已开启且在范围内',
									icon: 'none',
									duration: 3000
								});
								
								// 尝试关闭蓝牙连接
								try {
									GlobalBluetoothManager.disconnect();
								} catch (e) {
									console.error("断开连接失败:", e);
								}
							}
						}, 30000);
						
						// 使用带重试的连接方法
						return this.connectBluetoothWithRetry(deviceId)
							.then(result => {
								// 连接成功，清除超时定时器
								clearTimeout(connectTimeout);
								return result;
							})
							.catch(err => {
								// 连接失败，清除超时定时器
								clearTimeout(connectTimeout);
								throw err; // 继续抛出错误供后续处理
							});
					})
					.then((serviceInfo) => {
						console.log('蓝牙设备连接成功，获取到服务:', serviceInfo);
						this.setConnectionStatus('连接成功!', 'success');
						uni.hideLoading();
						
						// 显示设备信息，帮助调试
						setTimeout(() => {
							console.log("准备跳转到充电页面，设备ID:", deviceId);
							// 跳转到充电页面并传递参数
							try {
								// 检查设备ID是否有效
								if (!deviceId) {
									throw new Error("设备ID无效");
								}
								
								uni.navigateTo({
									url: `/pages/charging-progress/charging-progress?deviceId=${encodeURIComponent(deviceId)}`,
									fail: (err) => {
										console.error('导航到充电页面失败', err);
										uni.showToast({
											title: '页面跳转失败，请重试',
											icon: 'none'
										});
									}
								});
							} catch (e) {
								console.error('导航异常', e);
								uni.showToast({
									title: '页面跳转失败，请重试',
									icon: 'none'
								});
							}
						}, 1000); // 延迟以确保连接稳定
					})
					.catch(err => {
						console.error('连接蓝牙设备失败:', err);
						
						// 获取更多错误详情
						const lastError = GlobalBluetoothManager.bluetoothManager.getLastError();
						console.log('连接失败详情:', lastError);
						
						// 根据错误类型显示不同提示
						let errorMsg = '连接失败，请确认充电桩已开启并在范围内';
						
						if (err.errCode === 10001) {
							errorMsg = '请开启蓝牙功能';
						} else if (err.errCode === 10002) {
							errorMsg = '当前设备不支持蓝牙功能';
						} else if (err.errCode === 10003 || err.errCode === 10009) {
							errorMsg = '找不到指定设备，请确认充电桩在范围内';
						} else if (err.errCode === 10012) {
							errorMsg = '连接超时，请重试';
						} else if (err.message && err.message.includes('最大重试次数')) {
							errorMsg = '多次连接失败，请确认设备已开启并在范围内';
						} else if (lastError && lastError.phase === '获取服务') {
							errorMsg = '无法获取设备服务，请确认充电桩型号兼容';
						}
						
						this.setConnectionStatus(errorMsg, 'error');
						uni.hideLoading();
						uni.showToast({
							title: errorMsg,
							icon: 'none',
							duration: 3000
						});
					});
			},
			
			/**
			 * 格式化MAC地址以适应蓝牙连接要求
			 * @param {string} macAddress - 原始MAC地址 
			 * @returns {string} - 格式化后的MAC地址
			 */
			formatMacAddress(macAddress) {
				console.log("原始MAC地址:", macAddress);
				return cleanMac;
			},
			
			// 显示信息
			showInfo() {
				uni.showModal({
					title: '使用说明',
					content: '请将摄像头对准充电桩上的二维码，保持稳定，系统会自动识别并连接充电桩。如果连接失败，请确保:\n1. 手机蓝牙已开启\n2. 充电桩已开启且在范围内\n3. 扫描的二维码正确',
					showCancel: false
				});
			},
			
			// 连接蓝牙设备
			connectBluetoothDevice(deviceId) {
				// 确保蓝牙是可用的
				return this.initBluetoothWithRetry()
					.then(() => {
						this.setConnectionStatus(`正在连接设备: ${deviceId}...`, 'info');
						
						// 设置连接超时 - 增加到30秒
						const connectTimeout = setTimeout(() => {
							if (GlobalBluetoothManager.bluetoothManager.isConnecting) {
								const lastError = GlobalBluetoothManager.bluetoothManager.getLastError();
								const errorDetails = lastError ? `(${lastError.phase}: ${lastError.message})` : '';
								
								this.setConnectionStatus(`连接超时 ${errorDetails}`, 'error');
								try {
									uni.hideLoading();
								} catch (e) {
									console.warn('隐藏 loading 失败:', e);
								}
								uni.showToast({
									title: '连接超时，请确认充电桩已开启且在范围内',
									icon: 'none',
									duration: 3000
								});
								
								try {
									GlobalBluetoothManager.disconnect();
								} catch (e) {
									console.error("断开连接失败:", e);
								}
							}
						}, 30000);
						
						// 使用带重试的连接方法
						return this.connectBluetoothWithRetry(deviceId)
							.then(result => {
								// 连接成功，清除超时定时器
								clearTimeout(connectTimeout);
								return result;
							})
							.catch(err => {
								// 连接失败，清除超时定时器
								clearTimeout(connectTimeout);
								throw err; // 继续抛出错误供后续处理
							});
					})
					.then(() => {
						// 连接成功后获取服务
						return GlobalBluetoothManager.bluetoothManager.getDeviceServices(deviceId);
					})
					.then((services) => {
						if (!services || services.length === 0) {
							throw new Error("未找到蓝牙服务");
						}
						
						// 过滤服务，寻找目标服务
						const targetService = services.find(service => 
							service.uuid.toLowerCase().includes('6e400001') || // 常见串口服务
							service.isPrimary // 如果是主服务
						);
						
						if (!targetService) {
							throw new Error("未找到目标蓝牙服务");
						}
						
						// 获取特征值
						return GlobalBluetoothManager.bluetoothManager.getCharacteristics(deviceId, targetService.uuid)
							.then(characteristics => {
								return {
									serviceId: targetService.uuid,
									characteristics
								};
							});
					})
					.then(({ serviceId, characteristics }) => {
						if (!characteristics || characteristics.length === 0) {
							throw new Error("未找到蓝牙特征值");
						}
						
						// 寻找写入和通知的特征值
						const writeCharacteristic = characteristics.find(c => c.properties.write);
						const notifyCharacteristic = characteristics.find(c => c.properties.notify || c.properties.indicate);
						
						if (!writeCharacteristic || !notifyCharacteristic) {
							throw new Error("未找到所需蓝牙特征值");
						}
						
						// 启用通知
						return GlobalBluetoothManager.bluetoothManager.notifyCharacteristic(
							deviceId, 
							serviceId, 
							notifyCharacteristic.uuid, 
							true
						).then(() => {
							// 返回服务信息
							return {
								deviceId,
								serviceId,
								writeCharacteristic,
								notifyCharacteristic
							};
						});
					})
					.then((serviceInfo) => {
						console.log('蓝牙设备连接成功，并启用通知:', serviceInfo);
						this.setConnectionStatus('连接成功!', 'success');
						uni.hideLoading();
						
						// 延迟一秒后跳转到充电页面
						setTimeout(() => {
							uni.navigateTo({
								url: `/pages/charging-progress/charging-progress?deviceId=${encodeURIComponent(deviceId)}`,
								fail: (err) => {
									console.error('导航到充电页面失败', err);
									uni.showToast({
										title: '页面跳转失败，请重试',
										icon: 'none'
									});
								}
							});
						}, 1000); // 延迟以确保连接稳定
						
						return serviceInfo;
					})
					.catch((error) => {
						console.error('连接蓝牙设备或获取服务失败:', error);
						
						// 获取更多错误详情
						const lastError = GlobalBluetoothManager.bluetoothManager.getLastError();
						console.log('连接失败详情:', lastError);
						
						// 根据错误类型显示不同提示
						let errorMsg = '连接失败，请确认充电桩已开启并在范围内';
						
						if (error.errCode === 10001) {
							errorMsg = '请开启蓝牙功能';
						} else if (error.errCode === 10002) {
							errorMsg = '当前设备不支持蓝牙功能';
						} else if (error.errCode === 10003 || error.errCode === 10009) {
							errorMsg = '找不到指定设备，请确认充电桩在范围内';
						} else if (error.errCode === 10012) {
							errorMsg = '连接超时，请重试';
						} else if (error.errMsg && error.errMsg.includes('notifyBLECharacteristicValueChange')) {
							errorMsg = '启用蓝牙通知失败，请重试';
						}
						
						this.setConnectionStatus(errorMsg, 'error');
						uni.hideLoading();
						uni.showToast({
							title: errorMsg,
							icon: 'none',
							duration: 3000
						});
						
						// 尝试断开连接
						try {
							GlobalBluetoothManager.disconnect();
						} catch (e) {
							console.error('断开蓝牙连接失败:', e);
						}
						
						throw error;
					});
			}
		}
	}
</script>

<style lang="scss">
	.index-container {
		display: flex;
		flex-direction: column;
		min-height: 100vh;
		background-color: #ffffff;
	}

	.header {
		height: 88rpx;
		background-color: #2196f3;
		display: flex;
		justify-content: center;
		align-items: center;
		
		.time {
			color: #ffffff;
			font-size: 32rpx;
		}
	}

	.scan-container {
		flex: 1;
		display: flex;
		flex-direction: column;
		align-items: center;
		padding: 60rpx 40rpx 180rpx;
		
		.scan-box {
			width: 100%;
			display: flex;
			justify-content: center;
			align-items: center;
			margin: 60rpx 0;
			
			.scan-frame {
				width: 600rpx;
				height: 600rpx;
				border: 4rpx dashed #2196f3;
				background-color: rgba(241, 241, 241, 0.5);
				position: relative;
				overflow: hidden;
				
				.scan-line {
					position: absolute;
					left: 0;
					width: 100%;
					height: 4rpx;
					background: linear-gradient(to right, transparent, #2196f3, #2196f3, transparent);
					box-shadow: 0 0 10rpx #2196f3;
				}
			}
		}
		
		.scan-tip {
			margin-top: 40rpx;
			font-size: 32rpx;
			color: #2196f3;
		}
		
		.connection-status {
			margin-top: 30rpx;
			padding: 10rpx 30rpx;
			border-radius: 30rpx;
			font-size: 26rpx;
			max-width: 80%;
			text-align: center;
			
			&.status-info {
				background-color: rgba(33, 150, 243, 0.1);
				color: #2196f3;
				border: 1px solid #2196f3;
			}
			
			&.status-success {
				background-color: rgba(76, 175, 80, 0.1);
				color: #4CAF50;
				border: 1px solid #4CAF50;
			}
			
			&.status-error {
				background-color: rgba(244, 67, 54, 0.1);
				color: #F44336;
				border: 1px solid #F44336;
			}
		}
		
		.info-btn {
			margin-top: 60rpx;
			width: 80rpx;
			height: 80rpx;
			border-radius: 40rpx;
			background-color: #2196f3;
			display: flex;
			justify-content: center;
			align-items: center;
			
			.info-icon {
				color: #ffffff;
				font-size: 36rpx;
				font-weight: bold;
			}
		}
	}
</style>